{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05. Noisy Networks for Exploration\n",
    "\n",
    "[M. Fortunato et al., \"Noisy Networks for Exploration.\" arXiv preprint arXiv:1706.10295, 2017.](https://arxiv.org/pdf/1706.10295.pdf)\n",
    "\n",
    "\n",
    "NoisyNet is an exploration method that learns perturbations of the network weights to drive exploration. The key insight is that a single change to the weight vector can induce a consistent, and potentially very complex, state-dependent change in policy over multiple time steps.\n",
    "\n",
    "Firstly, let's take a look into a linear layer of a neural network with $p$ inputs and $q$ outputs, represented by\n",
    "\n",
    "$$\n",
    "y = wx + b,\n",
    "$$\n",
    "\n",
    "where $x \\in \\mathbb{R}^p$ is the layer input, $w \\in \\mathbb{R}^{q \\times p}$, and $b \\in \\mathbb{R}$ the bias.\n",
    "\n",
    "The corresponding noisy linear layer is defined as:\n",
    "\n",
    "$$\n",
    "y = (\\mu^w + \\sigma^w \\odot \\epsilon^w) x + \\mu^b + \\sigma^b \\odot \\epsilon^b,\n",
    "$$\n",
    "\n",
    "where $\\mu^w + \\sigma^w \\odot \\epsilon^w$ and $\\mu^b + \\sigma^b \\odot \\epsilon^b$ replace $w$ and $b$ in the first linear layer equation. The parameters $\\mu^w \\in \\mathbb{R}^{q \\times p}, \\mu^b \\in \\mathbb{R}^q, \\sigma^w \\in \\mathbb{R}^{q \\times p}$ and $\\sigma^b \\in \\mathbb{R}^q$ are learnable, whereas $\\epsilon^w \\in \\mathbb{R}^{q \\times p}$ and $\\epsilon^b \\in \\mathbb{R}^q$ are noise random variables which can be generated by one of the following two ways:\n",
    "\n",
    "1. **Independent Gaussian noise**: the noise applied to each weight and bias is independent, where each random noise entry is drawn from a unit Gaussian distribution. This means that for each noisy linear layer, there are $pq + q$ noise variables (for $p$ inputs to the layer and $q$ outputs).\n",
    "2. **Factorised Gaussian noise:** This is a more computationally efficient way. It produces 2 random Gaussian noise vectors ($p, q$) and makes $pq + q$ noise entries by outer product as follows:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\epsilon_{i,j}^w &= f(\\epsilon_i) f(\\epsilon_j),\\\\\n",
    "\\epsilon_{j}^b &= f(\\epsilon_i),\\\\\n",
    "\\text{where } f(x) &= sgn(x) \\sqrt{|x|}.\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "In all experiements of the paper, the authors used Factorised Gaussian noise, so we will go for it as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noisy Layer\n",
    "\n",
    "**References:**\n",
    "- https://github.com/higgsfield/RL-Adventure/blob/master/5.noisy%20dqn.ipynb\n",
    "- https://github.com/Kaixhin/Rainbow/blob/master/model.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NoisyLinear(nn.Module):\n",
    "    \"\"\"Noisy linear module for NoisyNet.\n",
    "    \n",
    "    Attributes:\n",
    "        in_features (int): input size of linear module\n",
    "        out_features (int): output size of linear module\n",
    "        std_init (float): initial std value\n",
    "        weight_mu (nn.Parameter): mean value weight parameter\n",
    "        weight_sigma (nn.Parameter): std value weight parameter\n",
    "        bias_mu (nn.Parameter): mean value bias parameter\n",
    "        bias_sigma (nn.Parameter): std value bias parameter\n",
    "        \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, in_features: int, out_features: int, std_init: float = 0.5):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "        self.std_init = std_init\n",
    "\n",
    "        self.weight_mu = nn.Parameter(torch.Tensor(out_features, in_features))\n",
    "        self.weight_sigma = nn.Parameter(\n",
    "            torch.Tensor(out_features, in_features)\n",
    "        )\n",
    "        self.register_buffer(\n",
    "            \"weight_epsilon\", torch.Tensor(out_features, in_features)\n",
    "        )\n",
    "\n",
    "        self.bias_mu = nn.Parameter(torch.Tensor(out_features))\n",
    "        self.bias_sigma = nn.Parameter(torch.Tensor(out_features))\n",
    "        self.register_buffer(\"bias_epsilon\", torch.Tensor(out_features))\n",
    "\n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        \"\"\"Reset trainable network parameters (factorized gaussian noise).\"\"\"\n",
    "        mu_range = 1 / math.sqrt(self.in_features)\n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(\n",
    "            self.std_init / math.sqrt(self.in_features)\n",
    "        )\n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(\n",
    "            self.std_init / math.sqrt(self.out_features)\n",
    "        )\n",
    "\n",
    "    def reset_noise(self):\n",
    "        \"\"\"Make new noise.\"\"\"\n",
    "        epsilon_in = self.scale_noise(self.in_features)\n",
    "        epsilon_out = self.scale_noise(self.out_features)\n",
    "\n",
    "        # outer product\n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(epsilon_out)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\n",
    "        \n",
    "        We don't use separate statements on train / eval mode.\n",
    "        It doesn't show remarkable difference of performance.\n",
    "        \"\"\"\n",
    "        return F.linear(\n",
    "            x,\n",
    "            self.weight_mu + self.weight_sigma * self.weight_epsilon,\n",
    "            self.bias_mu + self.bias_sigma * self.bias_epsilon,\n",
    "        )\n",
    "    \n",
    "    @staticmethod\n",
    "    def scale_noise(size: int) -> torch.Tensor:\n",
    "        \"\"\"Set scale to make noise (factorized gaussian noise).\"\"\"\n",
    "        x = torch.FloatTensor(np.random.normal(loc=0.0, scale=1.0, size=size))\n",
    "\n",
    "        return x.sign().mul(x.abs().sqrt())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noisy Network\n",
    "\n",
    "We use NoisyLinear for the last two FC layers, and there is a method to reset noise at every step.\n",
    "These are the only differences from the example of *01.dqn.ipynb*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.feature = nn.Linear(in_dim, 128)\n",
    "        self.noisy_layer1 = NoisyLinear(128, 128)\n",
    "        self.noisy_layer2 = NoisyLinear(128, out_dim)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        feature = F.relu(self.feature(x))\n",
    "        hidden = F.relu(self.noisy_layer1(feature))\n",
    "        out = self.noisy_layer2(hidden)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        \"\"\"Reset all noisy layers.\"\"\"\n",
    "        self.noisy_layer1.reset_noise()\n",
    "        self.noisy_layer2.reset_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + NoisyNet Agent (w/o DuelingNet)\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "In the paper, NoisyNet is used as a component of the Dueling Network Architecture, which includes Double-DQN and Prioritized Experience Replay. However, we don't implement them to simplify the tutorial. One thing to note is that NoisyNet is an alternertive to $\\epsilon$-greedy method, so all $\\epsilon$ related lines are removed. Please check all comments with *NoisyNet*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        # NoisyNet: All attributes related to epsilon are removed\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # NoisyNet: no epsilon greedy action selection\n",
    "        selected_action = self.dqn(\n",
    "            torch.FloatTensor(state).to(self.device)\n",
    "        ).argmax()\n",
    "        selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # NoisyNet: reset noise\n",
    "        self.dqn.reset_noise()\n",
    "        self.dqn_target.reset_noise()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # NoisyNet: removed decrease of epsilon\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 50\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.3.13818.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
